import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

/*问题一：“线程被执行后不会被销毁，而是重新放回到线程池中”——这一构想是如何在线程池中实现的？
    a、在此处由于生产线程的速度低于取出线程的速度，所以线程池不存在满的情况——我将加上sleep测试池子满的情况
    a1:将一次取出整个池子里的元素。起码看起来是这样.  但是我的设想是：每3秒取出一个元素
    a2、经测试发现，当生产速度大于消费速度时

    我忽视了一个重要条件：它是创建出线程池最大数量的多个线程，每个线程去执行一个从池子中取出的元素。而且它们是并发执行的！！！

    b、当池子满的时候，主线程是否还在生产线程？
* 问题二：线程池的拒绝策略有四个，我怎么知道它用的是哪个策略？
        如果不设定的话将直接调用默认策略——这是真正的线程池中才有的配置，现在写的只是个简化版*/
class MyThreadPool{
    //建立一个阻塞队列用于存放任务
    public BlockingQueue<Runnable> queue = new LinkedBlockingQueue<>();
    //写一个方法用于向队列中放入元素
    public void submit(Runnable runnable) throws InterruptedException {
        queue.put(runnable);
    }
/*这是一个构造方法。
* 当线程池被创建时，会不断尝试从线程池中取出线程并执行
* 形参n为线程池的大小*/
    public MyThreadPool(int n){
        for (int i = 0; i < n; i++) {
            Thread t = new Thread(()->{
                try{
                    while (true){
                        Thread.sleep(3000);
                        Runnable runnable = queue.take();
                        runnable.run();

                    }
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
            });
            t.start();
        }
    }

}
public class Main {
    public static void main(String[] args) throws InterruptedException {
        MyThreadPool pool = new MyThreadPool(10);
        for (int i = 0; i < 50; i++) {
            int number = i;
            /*向线程池中放入新建立的线程*/
            pool.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println("hello" + number);
                }
            });
            Thread.sleep(500);
        }
    }
}
